var _n34;
var cc__extends = __extends;
var cc__decorate = __decorate;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$RopeSegmentManager = require("RopeSegmentManager");
var s = cc__importDefault($1$RopeSegmentManager);
var cc__decorator = cc._decorator;
var ccp_ccclass = cc__decorator.ccclass;
var ccp_property = cc__decorator.property;
var def_RopeTexture = function (t) {
  function _ctor() {
    // 使用 apply 方法调用 t，或者使用当前上下文
    var instance = null !== t && t.apply(this, arguments) || this;

    // 初始化实例属性
    instance.type = -1; // 类型
    instance.endX = 0; // 结束 X 坐标
    instance.endY = -300; // 结束 Y 坐标
    instance.overlap = 28; // 重叠值
    instance.offsetY = -2; // Y 坐标偏移
    instance.amplitude = 20; // 振幅
    instance.frequency = 2; // 频率
    instance.waveCount = 1; // 波数
    instance.SEGMENT_SIZE = 32; // 段大小
    instance.TWO_PI = 2 * Math.PI; // 2π
    instance.segments = []; // 段数组
    instance.originalPositions = []; // 原始位置数组
    instance.segmentCount = 0; // 段计数
    instance.time = 0; // 时间
    instance.lastAngles = []; // 上一帧角度数组
    instance.lastPositions = []; // 上一帧位置数组
    instance.SMOOTH_SPEED = 0.3; // 平滑速度
    instance.isMoving = false; // 是否正在移动
    instance.moveStartX = 0; // 移动起始 X 坐标
    instance.moveStartY = 0; // 移动起始 Y 坐标
    instance.moveTargetX = 0; // 移动目标 X 坐标
    instance.moveTargetY = 0; // 移动目标 Y 坐标
    instance.moveTime = 0; // 移动持续时间
    instance.moveElapsed = 0; // 已经过的时间

    return instance; // 返回实例
  }
  cc__extends(_ctor, t);
  _ctor.prototype.onLoad = function () { };
  _ctor.prototype.updateEndPoint = function (t, e) {
    // 计算从原点到点 (t, e) 的向量的长度
    var distance = cc.v2(t, e).mag();

    // 计算每个段的有效大小
    var segmentSize = this.SEGMENT_SIZE - this.overlap + this.offsetY;

    // 计算需要的段数
    var requiredSegments = Math.ceil(distance / segmentSize);

    // 计算波动段数
    var amplitudeSegments = Math.ceil((this.amplitude / segmentSize) * 2);

    // 计算总段数，确保至少为 5
    var totalSegments = Math.max(5, requiredSegments + amplitudeSegments);

    // 如果计算出的段数与当前段数不同，则更新段数
    if (totalSegments !== this.segmentCount) {
      this.updateSegmentCount(totalSegments);
    }

    // 更新绳索段
    this.updateRopeSegments(t, e);
  };
  _ctor.prototype.updateSegmentCount = function (t) {
    // 计算需要添加或移除的段数
    var difference = t - this.segmentCount;

    // 如果需要添加段
    if (difference > 0) {
      for (var i = 0; i < difference; i++) {
        var segment = s.default.getInstance().getSegment(this.type); // 获取一个新段
        segment.parent = this.node; // 设置段的父节点
        this.segments.push(segment); // 将段添加到数组
      }
    }
    // 如果需要移除段
    else if (difference < 0) {
      for (var i = 0; i < -difference; i++) {
        var segmentToRemove = this.segments.pop(); // 移除最后一段
        if (segmentToRemove) {
          s.default.getInstance().putSegment(this.type, segmentToRemove); // 归还段
        }
      }
    }

    // 更新段计数
    this.segmentCount = t;
  };
  _ctor.prototype.updateRopeSegments = function (t, e) {
    // 获取当前段数
    var segmentCount = this.segments.length;

    // 检查 originalPositions 数组的长度是否与段数一致
    if (this.originalPositions.length !== segmentCount) {
      // 初始化 originalPositions、lastAngles 和 lastPositions 数组
      this.originalPositions = new Array(segmentCount);
      this.lastAngles = new Array(segmentCount);
      this.lastPositions = new Array(segmentCount);

      // 为每个段设置初始值
      for (var index = 0; index < segmentCount; index++) {
        this.originalPositions[index] = cc.v2(); // 初始化原始位置
        this.lastPositions[index] = cc.v2(); // 初始化最后位置
        this.lastAngles[index] = 0; // 初始化最后角度
      }
    }

    // 更新每个段的位置和角度
    for (var index = 0; index < segmentCount; index++) {
      var segment = this.segments[index];
      var ratio = index / (segmentCount - 1); // 计算当前段的比例
      var posX = ratio * t; // 计算X坐标
      var posY = ratio * e; // 计算Y坐标

      // 更新原始位置
      this.originalPositions[index].x = posX;
      this.originalPositions[index].y = posY;

      // 更新当前段的位置
      segment.x = posX;
      segment.y = posY;

      if (index < segmentCount - 1) {
        // 计算下一个段的角度
        var nextRatio = (index + 1) / (segmentCount - 1);
        var deltaX = nextRatio * t - segment.x;
        var deltaY = nextRatio * e - segment.y;
        var angle = 180 * Math.atan2(deltaY, deltaX) / Math.PI - 90;

        // 使用线性插值平滑过渡角度
        this.lastAngles[index] = cc.misc.lerp(this.lastAngles[index], angle, this.SMOOTH_SPEED);
        segment.angle = this.lastAngles[index];
      } else {
        // 对于最后一个段，使用前一个段的角度
        segment.angle = this.lastAngles[index - 1] || 0;
      }
    }
  };
  _ctor.prototype.moveToTarget = function (t, e, o) {
    this.isMoving = true;
    this.moveStartX = this.endX;
    this.moveStartY = this.endY;
    this.moveTargetX = t;
    this.moveTargetY = e;
    this.moveTime = o;
    this.moveElapsed = 0;
  };
  _ctor.prototype.update = function (t) {
    // 如果正在移动
    if (this.isMoving) {
      this.moveElapsed += t; // 增加已移动时间

      // 检查是否已达到目标时间
      if (this.moveElapsed >= this.moveTime) {
        this.endX = this.moveTargetX; // 设置结束X坐标
        this.endY = this.moveTargetY; // 设置结束Y坐标
        this.isMoving = false; // 停止移动
      } else {
        // 计算当前进度
        var progress = this.moveElapsed / this.moveTime;
        this.endX = cc.misc.lerp(this.moveStartX, this.moveTargetX, progress); // 插值计算X坐标
        this.endY = cc.misc.lerp(this.moveStartY, this.moveTargetY, progress); // 插值计算Y坐标
      }

      // 更新结束点
      this.updateEndPoint(this.endX, this.endY);
    }

    // 增加整体时间
    this.time += t;

    // 更新波动段
    var segmentCount = this.segments.length;
    if (segmentCount !== 0) {
      var frequencyMultiplier = this.time * this.frequency; // 频率乘数
      var waveMagnitude = this.TWO_PI * this.waveCount; // 波动幅度

      // 更新每个段的位置
      for (var index = 0; index < segmentCount; index++) {
        var segment = this.segments[index];
        if (segment && segment.active) {
          var relativePosition = index / (segmentCount - 1); // 当前段的位置比例
          var wavePosition = frequencyMultiplier + relativePosition * waveMagnitude; // 当前波动位置
          var originalPosition = this.originalPositions[index]; // 获取原始位置

          // 计算新的Y坐标并更新段
          var offset = Math.sin(wavePosition) * this.amplitude * Math.sin(relativePosition * Math.PI);
          segment.x = originalPosition.x + offset; // 更新X坐标
          segment.y = originalPosition.y; // Y坐标保持不变
        }
      }
    }
  };
  _ctor.prototype.destroyByReset = function () {
    // 获取当前上下文
    var context = this;

    // 归还每个段到池中
    this.segments.forEach(function (segment) {
      if (segment) {
        s.default.getInstance().putSegment(context.type, segment); // 归还段
      }
    });

    // 清空段数组
    this.segments = [];

    // 销毁当前节点
    this.node.destroy();
  };
  _ctor.prototype.easeInOut = function (t) {
    if (t < 0.5) {
      return 2 * t * t;
    } else {
      return (4 - 2 * t) * t - 1;
    }
  };
  cc__decorate([ccp_property({
    tooltip: "终点X坐标",
    type: cc.Float,
    displayName: "终点X"
  })], _ctor.prototype, "endX", undefined);
  cc__decorate([ccp_property({
    tooltip: "终点Y坐标",
    type: cc.Float,
    displayName: "终点Y"
  })], _ctor.prototype, "endY", undefined);
  cc__decorate([ccp_property({
    tooltip: "段落之间的重叠像素数",
    type: cc.Integer,
    min: 0,
    max: 31,
    step: 1,
    displayName: "重叠像素"
  })], _ctor.prototype, "overlap", undefined);
  cc__decorate([ccp_property({
    tooltip: "段落之间的间距偏移",
    type: cc.Integer,
    min: -5,
    max: 5,
    step: 1,
    displayName: "间距微调"
  })], _ctor.prototype, "offsetY", undefined);
  cc__decorate([ccp_property({
    tooltip: "水平摆动幅度",
    type: cc.Float,
    min: 0,
    step: 1,
    displayName: "水平幅度"
  })], _ctor.prototype, "amplitude", undefined);
  cc__decorate([ccp_property({
    tooltip: "波浪频率",
    type: cc.Float,
    min: .1,
    step: .1,
    displayName: "摆动频率"
  })], _ctor.prototype, "frequency", undefined);
  cc__decorate([ccp_property({
    tooltip: "波浪数量",
    type: cc.Float,
    min: .1,
    max: 10,
    step: .1,
    displayName: "波浪数量"
  })], _ctor.prototype, "waveCount", undefined);
  return cc__decorate([ccp_ccclass], _ctor);
}(cc.Component);
exports.default = def_RopeTexture;